#include "stdafx.h"
#include "computil.h"
#include <Commerce.h>


HRESULT GetNumValueOfVariant(VARIANT* pvar, int* pvalue)
{
	HRESULT hr = S_OK;
	if (SUCCEEDED(hr = VariantChangeType(pvar, pvar, 0, VT_I4)))
		*pvalue = V_I4(pvar);
	return hr;
}

HRESULT GetStringValueOfVariant(VARIANT* pvar, BSTR* pvalue)
{
	HRESULT hr = S_OK;
	if (SUCCEEDED(hr = VariantChangeType(pvar, pvar, 0, VT_BSTR)))
		*pvalue = V_BSTR(pvar);
	return hr;
}



HRESULT PutDictValue(IDictionary* pdict, LPCWSTR name, VARIANT& var)
{
    HRESULT hr = S_OK;
	BSTR bstrName = SysAllocString(name);
	if ( !bstrName )
		return E_OUTOFMEMORY;
    hr = pdict->put_Value(bstrName, var);
	SysFreeString(bstrName);
	return hr;
}

HRESULT PutDictValue(IDictionary* pdict, LPCWSTR name, int value)
{
    HRESULT hr = S_OK;
	VARIANT v[1];
    VariantInit(v);
	BSTR bstrName = SysAllocString(name);
	if ( !bstrName )
		return E_OUTOFMEMORY;

	V_VT(v) = VT_I4;
	V_I4(v) = value;
    hr = pdict->put_Value(bstrName, *v);

    VariantClear(v);
	SysFreeString(bstrName);
	return hr;
}

HRESULT PutDictValue(IDictionary* pdict, LPCWSTR name, LPCWSTR value)
{
    HRESULT hr = S_OK;
	VARIANT v[1];
    VariantInit(v);
	BSTR bstrValue = NULL;
	BSTR bstrName = SysAllocString(name);
	if ( !bstrName )
	{
		hr = E_OUTOFMEMORY;
		goto Error;
	}	
	bstrValue = SysAllocString(value);
	if (!bstrValue)
	{
		hr = E_OUTOFMEMORY;
		goto Error;
	}	

	V_VT(v)   = VT_BSTR;
	V_BSTR(v) = bstrValue;
    hr = pdict->put_Value(bstrName, *v);

Error:
    VariantClear(v);
	if ( bstrName ) SysFreeString(bstrName);
	return hr;
}


HRESULT GetDictValue(IDictionary* pdict, LPCWSTR name, VARIANT* pvar)
{
    HRESULT hr = S_OK;
	BSTR bstrName = SysAllocString(name);
	if ( !bstrName )
		return E_OUTOFMEMORY;
	
	hr = pdict->get_Value(bstrName, pvar);
	SysFreeString(bstrName);
	return hr;
}

HRESULT GetDictValue(IDictionary* pdict, LPCWSTR name, int* pvalue)
{
    HRESULT hr = S_OK;
	VARIANT v[1];
    VariantInit(v);
	BSTR bstrName = SysAllocString(name);
	if ( !bstrName )
		return E_OUTOFMEMORY;
	
	if (FAILED(hr = pdict->get_Value(bstrName, v)))
        goto done;      // replace "return hr;" to remove a leak of bstrName
    
	if (SUCCEEDED(hr = VariantChangeType(v, v, 0, VT_I4)))
		*pvalue = V_I4(v);

    VariantClear(v);

  done:
	SysFreeString(bstrName);
	return hr;
}

HRESULT GetDictValue(IDictionary* pdict, LPCWSTR name, BSTR* pvalue)
{
    HRESULT hr = S_OK;
	VARIANT v[1];
    VariantInit(v);
	BSTR bstrName = SysAllocString(name);
	if ( !bstrName )
		return E_OUTOFMEMORY;
	
	if (SUCCEEDED(hr = pdict->get_Value(bstrName, v)))
	{
		if (SUCCEEDED(hr = VariantChangeType(v, v, 0, VT_BSTR)))
			*pvalue = V_BSTR(v);
		else
			VariantClear(v);
	}
	SysFreeString(bstrName);
	return hr;
}

HRESULT GetListFromDict(IDictionary* pdictOrder, LPCWSTR wszName, ISimpleList** pplist)
{
	if ( !pplist) return S_OK;

    HRESULT hr = S_OK;
	VARIANT var;

	VariantInit(&var);
	*pplist = NULL;

	if (SUCCEEDED(hr = GetDictValue(pdictOrder,wszName,&var)))
	{
		if (V_VT(&var) != VT_DISPATCH && V_VT(&var) != VT_UNKNOWN)
			hr = E_UNEXPECTED;
		else
			hr = V_DISPATCH(&var)->QueryInterface(IID_ISimpleList, (void**)pplist);
	}
	VariantClear(&var);
	return hr;
}


HRESULT GetDictFromDispatch(IDispatch* pdisp, IDictionary** ppdict)
{
	HRESULT		 hr		= E_INVALIDARG;		// start pessimistic
	if ( pdisp )
		hr = pdisp->QueryInterface(IID_IDictionary, (void**)ppdict);
	return hr;
}

HRESULT GetSimpleListFromDispatch(IDispatch* pdisp, ISimpleList** pplist)
{
	HRESULT		 hr		= E_INVALIDARG;		// start pessimistic
	if ( pdisp )
		hr = pdisp->QueryInterface(IID_ISimpleList, (void**)pplist);
	return hr;
}

HRESULT GetNumItems(ISimpleList* pListItems, long* pcItems)
{
	return pListItems->get_Count(pcItems);
}

HRESULT GetNthItem(ISimpleList* pListItems, long iItem, IDictionary** ppdictItem)
{
    HRESULT hr = S_OK;
	VARIANT varItem;

	VariantInit(&varItem);
	*ppdictItem = NULL;

	if (FAILED(hr = pListItems->get_Item(iItem, &varItem)))
		return hr;

	if (V_VT(&varItem) != VT_DISPATCH && V_VT(&varItem) != VT_UNKNOWN)
		hr = E_UNEXPECTED;
	else
		hr = V_DISPATCH(&varItem)->QueryInterface(IID_IDictionary, (void**)ppdictItem);

	VariantClear(&varItem);
	return hr;
}


HRESULT InitKeyEnumInDict(IDictionary* pdict, IEnumVARIANT** ppenum)
{
	if(!pdict) return E_INVALIDARG;
	if(!ppenum) return E_INVALIDARG;

	IUnknown* punk = NULL;
	HRESULT hr = pdict->get__NewEnum(&punk);
	if ( SUCCEEDED(hr) )
	{
		hr = punk->QueryInterface(IID_IEnumVARIANT, (void **)ppenum);
		punk->Release();
	}
	return hr;
}

HRESULT GetNextKeyInDict(IEnumVARIANT* penum, BSTR* pbstrKey)
{
	if(!penum) return E_INVALIDARG;

	VARIANT		var;
	VariantInit(&var);
	HRESULT	hr = S_OK;

	hr = penum->Next(1, &var, NULL);
	if ( hr == S_OK )
	{
		hr = VariantChangeType(&var, &var, 0, VT_BSTR);
		if ( FAILED(hr) )
			hr = E_UNEXPECTED;
		else if ( pbstrKey )
		{
			if (*pbstrKey) SysFreeString(*pbstrKey);
			*pbstrKey = V_BSTR(&var);
			V_BSTR(&var) = 0;
			V_VT(&var) = VT_NULL;
		}
	}

	VariantClear(&var);
	return hr;
}



HRESULT
GetMsgFromMsgMan(IDispatch* pdispMsgMan, LPCWSTR wszErrMsgName, BSTR* pbstrMessage)
{
	HRESULT hr = S_OK;
	BSTR bstrMsgName = NULL;
    VARIANTARG      rgvar[1];
    DISPPARAMS      dispParams = { rgvar, NULL, 1, 0 };
    VARIANT         varRet;
	EXCEPINFO		excepinfo = { 0 };

    VariantInit(&rgvar[0]);
    VariantInit(&varRet);

    DISPID  dispid = 0;
    OLECHAR* szFnName = L"GetMessage";
    hr = pdispMsgMan->GetIDsOfNames(IID_NULL,&szFnName,1,
                            LOCALE_SYSTEM_DEFAULT,&dispid);
    if ( FAILED(hr) )
		goto Error;

    // generate the BSTR for the error message
    bstrMsgName = SysAllocString(wszErrMsgName);
    if ( !bstrMsgName )
    {
        hr = E_OUTOFMEMORY;
        goto Error;
    }

    rgvar[0].vt       = VT_BSTR;
    rgvar[0].bstrVal  = bstrMsgName;
    hr = pdispMsgMan->Invoke(dispid,
                                IID_NULL,
                                LOCALE_SYSTEM_DEFAULT,
                                DISPATCH_METHOD,
                                &dispParams,
                                &varRet,
                                &excepinfo,
                                NULL);
    if ( FAILED(hr) )
	{
		if ( hr == DISP_E_EXCEPTION )
		{
			hr = excepinfo.scode;
			if ( SUCCEEDED(hr) )
				hr = E_FAIL;		// default!
		}
		goto Error;
	}
    if ( V_VT(&varRet) == VT_BSTR )
    {
		if ( pbstrMessage )
		{
			*pbstrMessage = V_BSTR(&varRet);
			V_BSTR(&varRet) = NULL;
			V_VT(&varRet) = VT_EMPTY;
		}
	}
	else
        hr = E_UNEXPECTED;

Error:
	VariantClear(&rgvar[0]);
	VariantClear(&varRet);
	return hr;
}


HRESULT
AddErrToList(IDictionary* pdictOrder, 
			 LPCWSTR wszErrListName,
			 IDispatch* pdispContext,
			 LPCWSTR wszErrMsgName)
{
	if (!pdictOrder) return E_INVALIDARG;
	if (!wszErrListName) return E_INVALIDARG;
	if (!pdispContext) return E_INVALIDARG;
	if (!wszErrMsgName) return E_INVALIDARG;

	HRESULT		hr = S_OK;
	ISimpleList* plistErrors = NULL;
	IDictionary* pdictContext = NULL;
	VARIANT	varMsgMan;
	VariantInit(&varMsgMan);
	IDispatch* pdispMsgMan = NULL;
	BSTR bstrMsg = NULL;

	// get the list of errors
	hr = GetListFromDict(pdictOrder, wszErrListName, &plistErrors);
	if ( FAILED(hr) )
		goto Error;

	// get the context dictionary
	hr = GetDictFromDispatch(pdispContext,&pdictContext);
	if ( FAILED(hr) )
		goto Error;

	// get the message manager
	hr = GetDictValue(pdictContext, L"MessageManager", &varMsgMan);
	if ( FAILED(hr) )
		goto Error;
	hr = VariantChangeType(&varMsgMan, &varMsgMan, 0, VT_DISPATCH);
	if ( FAILED(hr) )
	{
		hr = E_UNEXPECTED;
		goto Error;
	}
	pdispMsgMan = V_DISPATCH(&varMsgMan);
	//V_DISPATCH(&varMsgMan) = NULL;
	//V_VT(&varMsgMan) = VT_NULL;

	// get the desired message
	hr = GetMsgFromMsgMan(pdispMsgMan,wszErrMsgName,&bstrMsg);
	if ( FAILED(hr) )
		goto Error;

	// add the retrieved error message to the list of errors
	{
		VARIANT var;

		VariantInit(&var);
		V_VT(&var) = VT_BSTR;
		V_BSTR(&var) = bstrMsg;
		hr = plistErrors->Add(&var);
        VariantClear(&var);
	}

Error:
	if (bstrMsg)  SysFreeString(bstrMsg);
    if (pdictContext)
        pdictContext->Release();
	VariantClear(&varMsgMan);
	if ( plistErrors )
		plistErrors->Release();
	return hr;
}



static unsigned short _table[] = L"0123456789ABCDEFGHJKLMNPQRSTUVWX";

/* This function takes as input a 32+1 character buffer */
HRESULT GenUniqueID(unsigned short * buf, BOOL fAddRandom)
{
   GUID guid;
   HRESULT hr;
   unsigned char data[20];
   short r;
   int i;

   /* Create a GUID */
   hr = CoCreateGuid(&guid);
   if (hr != S_OK)
     return hr;

   /* Copy the 16 bytes out of the GUID into our buffer */
   memcpy(data, &guid, 16);

   if ( fAddRandom )
   {
	   /* Generate 4 bytes of randomness...not very random without seeding */
	   srand(GetTickCount());		// works well

	   /* rand even though it returns an int in the c-runtime really returns a short */
	   r = short(rand());
	   memcpy(data + 16, &r, 2);
	   r = short(rand());
	   memcpy(data + 18, &r, 2);
   }
   else		// set to 0
   {
	   memset(data + 16, 0, 4);
   }

   /* 5 bit encode (base 32) the data 5 bytes at a time */
   for (i = 0; i < 4; i++)
   {
       buf[i * 8]     = _table[data[i*5] >>3];
       buf[i * 8 + 1] = _table[(data[i*5] & 0x07) | ((data[i*5 + 1] & 0x03) << 3)];
       buf[i * 8 + 2] = _table[data[i*5 + 1] >> 3];
       buf[i * 8 + 3] = _table[((data[i*5 + 1] & 0x04) << 1) | (data[i*5 + 2] & 0x07) | ((data[i*5 + 4] & 0x04) << 2)];
       buf[i * 8 + 4] = _table[data[i*5 + 2] >> 3];
       buf[i * 8 + 5] = _table[data[i*5 + 3] >> 3];
       buf[i * 8 + 6] = _table[(data[i*5 + 3] & 0x07) | ((data[i*5 + 4] & 0x03) << 3)];
       buf[i * 8 + 7] = _table[data[i*5 + 4] >> 3];
   }

   if ( fAddRandom )
   {
	   // 32 bytes written -- set the 33rd to the null terminate
	   buf[32] = 0;
   }
   else
   {
	   // null terminate at the appropriate element
	   buf[26] = 0;
   }

   return S_OK;   
}





HRESULT RegisterCATID(const CLSID& clsid, IID newCATID)
{
    //
    // connect to the class entry in the registry and write the two
    //  IIDs into the "Implemented Categories" section
    //


    WCHAR  wszNewKey[_MAX_PATH];

    WCHAR* pwszCLSID = NULL;
    StringFromCLSID(clsid, &pwszCLSID);

    static const WCHAR szImpCat[] = L"\\Implemented Categories\\";

    WCHAR* pwszCATID;
    StringFromCLSID(newCATID, &pwszCATID);

    wcscpy( wszNewKey, L"CLSID\\" );            // root\CLSID
    wcscat( wszNewKey, pwszCLSID );             // our class ID {xxxxxx-...xx}
    wcscat( wszNewKey, szImpCat );              // "Implemented Categories"
    wcscat( wszNewKey, pwszCATID );             // new catid

    //
    //  and the cat ids to put in there
    //

    LONG    lRes = 0;
    HRESULT hRes = S_OK;
    if (hRes == S_OK)
    {
        HKEY    kClass;     // bit bucket
        lRes = RegCreateKeyExW(  HKEY_CLASSES_ROOT,
                                    wszNewKey,
                                    0,
                                    NULL,
                                    0,
                                    KEY_ALL_ACCESS,
                                    NULL,
                                    &kClass,
                                    NULL
                                     );
        RegCloseKey( kClass );
    }
    CoTaskMemFree(pwszCLSID);
    CoTaskMemFree(pwszCATID);
    if (lRes != ERROR_SUCCESS)
        hRes = HRESULT_FROM_WIN32(lRes);
    return hRes;
}

HRESULT RegisterName(const CLSID& clsid, LPCWSTR wszName)
{


    WCHAR  wszNewKey[_MAX_PATH];

    WCHAR* pwszCLSID = NULL;
    StringFromCLSID(clsid, &pwszCLSID);

    static const WCHAR wszAuxUser[] = L"\\AuxUserType\\2\\";

    wcscpy( wszNewKey, L"CLSID\\" );            // root\CLSID
    wcscat( wszNewKey, pwszCLSID );             // our class ID {xxxxxx-...xx}
    wcscat( wszNewKey, wszAuxUser );

    LONG    lRes = 0;
    HRESULT hRes = S_OK;
    HKEY    hKey = 0;
    
	lRes = RegCreateKeyExW(HKEY_CLASSES_ROOT, wszNewKey, 0, NULL, 0,
			KEY_ALL_ACCESS, NULL, &hKey, NULL);
	if (lRes == ERROR_SUCCESS)
		lRes = RegSetValueW(hKey, NULL,	REG_SZ,
					wszName, wcslen(wszName)*sizeof(WCHAR));

    CoTaskMemFree(pwszCLSID);
    if (lRes != ERROR_SUCCESS)
        hRes = HRESULT_FROM_WIN32(lRes);
    return hRes;
}

HRESULT RegisterThreadingModel(const CLSID& clsid, LPCWSTR wszThreadingModel)
{


    WCHAR  wszNewKey[_MAX_PATH];

    WCHAR* pwszCLSID = NULL;
    StringFromCLSID(clsid, &pwszCLSID);

    static const WCHAR wszInprocServer[] = L"\\InProcServer32\\";

    wcscpy( wszNewKey, L"CLSID\\" );            // root\CLSID
    wcscat( wszNewKey, pwszCLSID );             // our class ID {xxxxxx-...xx}
    wcscat( wszNewKey, wszInprocServer );

    LONG    lRes = 0;
    HRESULT hRes = S_OK;
    HKEY    hKey = 0;
    
	lRes = RegCreateKeyExW(HKEY_CLASSES_ROOT, wszNewKey, 0, NULL, 0,
			KEY_ALL_ACCESS, NULL, &hKey, NULL);
	if (lRes == ERROR_SUCCESS)
		lRes = RegSetValueExW(hKey, L"ThreadingModel", 0, REG_SZ,
					(LPBYTE)wszThreadingModel, (wcslen(wszThreadingModel)+1)*sizeof(WCHAR));

    CoTaskMemFree(pwszCLSID);
    if (lRes != ERROR_SUCCESS)
        hRes = HRESULT_FROM_WIN32(lRes);
    return hRes;
}
